// ignore_for_file: dead_code

import 'dart:convert';
import 'dart:developer';
import 'dart:io';
import 'package:dio/dio.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart' hide FormData, MultipartFile;
import '../index.dart';
import 'http_pem.dart';

class HttpBaseUtil {
  /// BaseOptions、Options、RequestOptions 都可以配置参数，优先级别依次递增，且可以根据优先级别覆盖参数
  initBaseOptions(String baseUrl) {
    BaseOptions options = BaseOptions(
      // 请求基地址,可以包含子路径
      baseUrl: baseUrl,

      // baseUrl: storage.read(key: STORAGE_KEY_APIURL) ?? SERVICE_API_BASEURL,
      //连接服务器超时时间，单位是毫秒.
      connectTimeout: Duration(seconds: 60),

      // 响应流上前后两次接受到数据的间隔，单位为毫秒。
      receiveTimeout: Duration(seconds: 60),

      // Http请求头.
      headers: {},

      /// 请求的Content-Type，默认值是"application/json; charset=utf-8".
      /// 如果您想以"application/x-www-form-urlencoded"格式编码请求数据,
      /// 可以设置此选项为 `Headers.formUrlEncodedContentType`,  这样[Dio]
      /// 就会自动编码请求体.
      contentType: 'application/json; charset=utf-8',

      /// [responseType] 表示期望以那种格式(方式)接受响应数据。
      /// 目前 [ResponseType] 接受三种类型 `JSON`, `STREAM`, `PLAIN`.
      ///
      /// 默认值是 `JSON`, 当响应头中con tent-type为"application/json"时，dio 会自动将响应内容转化为json对象。
      /// 如果想以二进制方式接受响应数据，如下载一个二进制文件，那么可以使用 `STREAM`.
      ///
      /// 如果想以文本(字符串)格式接收响应数据，请使用 `PLAIN`.
      responseType: ResponseType.json,
    );
    return options;
  }

  /// Cookie管理
  initCookieManager() {
    // CookieJar cookieJar = CookieJar();
    // dio.interceptors.add(CookieManager(cookieJar));
  }

  ///拦截器
  InterceptorsWrapper httpInterceptorsWrapper() {
    return InterceptorsWrapper(
      onRequest: (options, handler) {
        if (Utils.isInDebugMode) {
          try {
            log('url===>${options.path}');
            log('header===>${options.headers}');
            log('queryParameters===>${options.queryParameters}');
            log('data====>${options.data}');
          } catch (e) {
            debugPrint('Request Error ===>$e');
          }
        }

        // Do something before request is sent
        return handler.next(options); //continue
        // 如果你想完成请求并返回一些自定义数据，你可以resolve一个Response对象 `handler.resolve(response)`。
        // 这样请求将会被终止，上层then会被调用，then中返回的数据将是你的自定义response.
        //
        // 如果你想终止请求并触发一个错误,你可以返回一个`DioError`对象,如`handler.reject(error)`，
        // 这样请求将被中止并触发异常，上层catchError会被调用。
      },
      onResponse: (response, ResponseInterceptorHandler handler) {
        if (Utils.isInDebugMode) {
          try {
            log('response====>${jsonEncode(response.data)}', level: 1);
          } catch (e) {
            debugPrint('Response Error ===>$e');
          }
        }
        if (response.data['code'].toString() != '200') {
          if (response.data['code'].toString() == '401') {
            toastInfo(msg: '请重新登录');
            UserStore.to.onLogout();
            // cancelRequests(HttpEGoUtil().cancelToken);
            // cancelRequests(HttpEmindUtil().cancelToken);
          }
          // else {
          //   toastInfo(msg: response.data['msg']);
          // }
        }
        // Do something with response data
        return handler.next(response); // continue
        // 如果你想终止请求并触发一个错误,你可以 reject 一个`DioError`对象,如`handler.reject(error)`，
        // 这样请求将被中止并触发异常，上层catchError会被调用。
      },
      onError: (DioError e, handler) {
        // /ego/track
        if (!e.requestOptions.path.contains('track')) {
          ErrorEntity eInfo = createErrorEntity(e);
          onError(eInfo);
        }
        return handler.next(e); //continue
        // 如果你想完成请求并返回一些自定义数据，可以resolve 一个`Response`,如`handler.resolve(response)`。
        // 这样请求将会被终止，上层then会被调用，then中返回的数据将是你的自定义response.
      },
    );
  }
  /*
   * error统一处理
   */

  // 错误处理
  void onError(ErrorEntity eInfo) {
    // ignore: avoid_print
    debugPrint(
        'error.code -> ${eInfo.code}, error.message -> ${eInfo.message}');
    switch (eInfo.code) {
      case 401:
        UserStore.to.onLogout();
        // EasyLoading.showError(eInfo.message);
        // showLoadingErrorWidget(eInfo.message);
        break;
      default:
        // EasyLoading.showError('未知错误');
        showLoadingErrorWidget(eInfo.message);
        break;
    }
  }

  // 错误信息
  ErrorEntity createErrorEntity(DioError error) {
    switch (error.type) {
      case DioExceptionType.cancel:
        return ErrorEntity(code: -1, message: "请求取消");
      case DioExceptionType.connectionTimeout:
        return ErrorEntity(code: -1, message: "连接超时");
      case DioExceptionType.sendTimeout:
        return ErrorEntity(code: -1, message: "请求超时");
      case DioExceptionType.receiveTimeout:
        return ErrorEntity(code: -1, message: "响应超时");
      case DioExceptionType.badResponse:
        {
          try {
            int errCode =
                error.response != null ? error.response!.data!['code'] : -1;
            // String errMsg = error.response.statusMessage;
            // return ErrorEntity(code: errCode, message: errMsg);
            switch (errCode) {
              case 400:
                return ErrorEntity(code: errCode, message: "请求语法错误");
              case 401:
                return ErrorEntity(code: errCode, message: "没有权限");
              case 403:
                return ErrorEntity(code: errCode, message: "服务器拒绝执行");
              case 404:
                return ErrorEntity(code: errCode, message: "无法连接服务器");
              case 405:
                return ErrorEntity(code: errCode, message: "请求方法被禁止");
              case 500:
                return ErrorEntity(code: errCode, message: "服务器内部错误");
              case 502:
                return ErrorEntity(code: errCode, message: "无效的请求");
              case 503:
                return ErrorEntity(code: errCode, message: "服务器挂了");
              case 505:
                return ErrorEntity(code: errCode, message: "不支持HTTP协议请求");
              default:
                {
                  return ErrorEntity(
                    code: errCode,
                    message: error.response != null
                        ? error.response!.statusMessage!
                        : "",
                  );
                }
            }
          } on Exception catch (_) {
            return ErrorEntity(code: -1, message: "未知错误");
          }
        }
      default:
        {
          return ErrorEntity(code: -1, message: error.message ?? '');
        }
    }
  }

  /*
   * 取消请求
   *
   * 同一个cancel token 可以用于多个请求，当一个cancel token取消时，所有使用该cancel token的请求都会被取消。
   * 所以参数可选
   */
  void cancelRequests(CancelToken token) {
    token.cancel("cancelled");
  }

  /// 读取本地配置
  Map<String, dynamic>? getAuthorizationHeader() {
    var headers = <String, dynamic>{};
    if (Get.isRegistered<UserStore>() && UserStore.to.hasToken == true) {
      headers['Authorization'] = 'Bearer ${UserStore.to.token.value}';
    }
    return headers;
  }

  ///显示 loading
  showLoadingWidget(showLoading) async {
    // if (showLoading) {
    //       EasyLoading.instance
    //   ..displayDuration = const Duration(milliseconds: 2000)
    //   ..indicatorType = EasyLoadingIndicatorType.fadingCircle
    //   ..loadingStyle = EasyLoadingStyle.dark
    //   ..indicatorSize = 45.0
    //   ..radius = 10.0
    //   ..progressColor = Colors.yellow
    //   ..backgroundColor = Colors.green
    //   ..indicatorColor = Colors.yellow
    //   ..textColor = Colors.yellow
    //   ..maskColor = Colors.blue.withOpacity(0.5)
    //   ..userInteractions = true
    //   ..dismissOnTap = false;

    //   EasyLoading.show(
    //       // status: '加载中...',
    //       indicator: Shimmer.fromColors(
    //           baseColor: AppColor.mainColor,
    //           period: const Duration(milliseconds: 3000),
    //           highlightColor: Colors.white10,
    //           child:
    //               Image.asset(Assets.images.launcher.egoIcon.path, width: 50)),
    //       maskType: EasyLoadingMaskType.clear);
    // }
    // await Future.delayed(const Duration(milliseconds: 500));
  }

  /// 显示错误信息
  showLoadingErrorWidget(message) {
    if (message != null) {
      toastInfo(msg: message);
      // EasyLoading.show(status: '加载中...', maskType: EasyLoadingMaskType.black);
    }
  }

  /// https证书
  HttpClient? Function(HttpClient?)? onHttpClientCreate = (client) {
    // List<String> PEM = httpPEM; // 你的地址证书内容
    client?.badCertificateCallback = (cert, host, port) {
      return true;
      for (var element in (httpPEM)) {
        if (cert.pem == element) {
          // 如果证书内容相同则验证通过
          return true;
        }
      }
      return false;
      // return true; // 返回true强制通过
      //   if (httpsPEM.contains(cert.pem)) {
      //     // 如果证书内容相同则验证通过
      //     return true;
      //   }
      //   return false;
      //   // return true; // 返回true强制通过
    };
    return null;
  };
}

// 异常处理
class ErrorEntity implements Exception {
  int code = -1;
  String message = "";
  ErrorEntity({required this.code, required this.message});

  @override
  String toString() {
    if (message == "") return "Exception";
    return "Exception: code $code, $message";
  }
}
